package controllers

import (
	"fmt"
	"log"
	"simple-crm/config"
	"simple-crm/models"
	"simple-crm/utils"
	"time"

	"github.com/gin-contrib/sessions"
	"github.com/gin-gonic/gin"
	"gorm.io/gorm"
)

type AuthController struct {
	DB  *gorm.DB
	Cfg *config.Config
}

type LoginRequest struct {
	Username string `json:"username" binding:"required"`
	Password string `json:"password" binding:"required"`
}

type LoginResponse struct {
	User      models.User `json:"user"`
	SessionID string      `json:"session_id"`
	Message   string      `json:"message"`
}

type RegisterRequest struct {
	Username string `json:"username" binding:"required"`
	Password string `json:"password" binding:"required,min=6"`
	RealName string `json:"real_name" binding:"required"`
	Phone    string `json:"phone"`
	Email    string `json:"email"`
}

type UpdateProfileRequest struct {
	RealName  string `json:"real_name" form:"real_name"`
	Phone     string `json:"phone" form:"phone"`
	Email     string `json:"email" form:"email"`
	Sign      string `json:"sign" form:"sign"`
	Gender    string `json:"gender" form:"gender"`
	AvatarURL string `json:"avatar_url" form:"avatar_url"`
}

type PasswordChangeRequest struct {
	OldPassword        string `json:"oldPassword" form:"oldPassword" binding:"required"`
	NewPassword        string `json:"newPassword" form:"newPassword" binding:"required,min=6"`
	ConfirmNewPassword string `json:"confirmNewPassword" form:"confirmNewPassword" binding:"required,eqfield=NewPassword"`
}

// NewAuthController 创建认证控制器
func NewAuthController(db *gorm.DB, cfg *config.Config) *AuthController {
	return &AuthController{
		DB:  db,
		Cfg: cfg,
	}
}

// Login 用户登录
func (ac *AuthController) Login(c *gin.Context) {
	log.Println("DEBUG: Entering Login function")
	var req LoginRequest
	if err := c.ShouldBind(&req); err != nil {
		utils.ValidationError(c, err)
		return
	}

	// 查找用户
	var user models.User
	if err := ac.DB.Where("username = ?", req.Username).First(&user).Error; err != nil {
		utils.Unauthorized(c, "用户名或密码错误")
		return
	}

	// 检查用户状态
	if user.Status != "active" {
		utils.Unauthorized(c, "用户已被禁用")
		return
	}

	// 验证密码
	if !utils.CheckPassword(req.Password, user.Password) {
		utils.Unauthorized(c, "用户名或密码错误")
		return
	}

	// 获取session
	session := sessions.Default(c)

	// 清除之前的session数据
	//session.Clear()

	// 存储用户信息到session
	session.Set("user_id", user.ID)
	session.Set("username", user.Username)
	session.Set("real_name", user.RealName)
	session.Set("status", user.Status)
	session.Set("login_time", time.Now().Unix())

	log.Println("DEBUG: Before session.Save()")
	//保存session
	if err := session.Save(); err != nil {
		log.Printf("Error saving session: %v\n", err)
		utils.InternalServerError(c, "保存会话失败: "+err.Error())
		return
	}

	fmt.Println("DEBUG: About to print session ID")
	log.Printf("Session ID: %s\n", session.ID())

	// 更新登录信息
	now := time.Now()
	user.LastLoginAt = &now
	user.LoginCount++
	ac.DB.Save(&user)

	// 记录登录日志
	models.LogUserLogin(ac.DB, user.ID, c.ClientIP(), c.GetHeader("User-Agent"))

	// 清除密码字段
	user.Password = ""

	// 返回响应
	response := LoginResponse{
		User:      user,
		SessionID: "111",
		Message:   "登录成功",
	}

	utils.SuccessWithMessage(c, "登录成功", response)

	// 调试：验证会话数据是否正确保存
	retrievedUserID := session.Get("user_id")
	retrievedUsername := session.Get("username")
	log.Printf("DEBUG: Retrieved from session - UserID: %v, Username: %v\n", retrievedUserID, retrievedUsername)
}

// Register 用户注册
func (ac *AuthController) Register(c *gin.Context) {
	var req RegisterRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		utils.ValidationError(c, err)
		return
	}

	// 检查用户名是否已存在
	var count int64
	ac.DB.Model(&models.User{}).Where("username = ?", req.Username).Count(&count)
	if count > 0 {
		utils.BadRequest(c, "用户名已存在")
		return
	}

	// 加密密码
	hashedPassword, err := utils.HashPassword(req.Password)
	if err != nil {
		utils.InternalServerError(c, "密码加密失败")
		return
	}

	// 创建用户
	user := models.User{
		Username: req.Username,
		Password: hashedPassword,
		RealName: req.RealName,
		Phone:    req.Phone,
		Email:    req.Email,
		Status:   "active",
	}

	if err := ac.DB.Create(&user).Error; err != nil {
		utils.InternalServerError(c, "创建用户失败")
		return
	}

	// 分配默认角色（如果存在）
	var defaultRole models.Role
	if err := ac.DB.Where("name = ?", "user").First(&defaultRole).Error; err == nil {
		userRole := models.UserRole{
			UserID:     user.ID,
			RoleID:     defaultRole.ID,
			AssignedAt: time.Now(),
		}
		ac.DB.Create(&userRole)
	}

	// 清除密码字段
	user.Password = ""

	utils.SuccessWithMessage(c, "注册成功", user)
}

// Logout 用户登出
func (ac *AuthController) Logout(c *gin.Context) {
	// 获取session
	session := sessions.Default(c)

	// 获取当前用户ID用于记录日志
	userID := session.Get("user_id")
	if userID != nil {
		if uid, ok := userID.(uint); ok {
			// 记录登出日志
			models.LogUserLogout(ac.DB, uid, c.ClientIP(), c.GetHeader("User-Agent"))
		}
	}

	// 清除session数据
	session.Clear()
	session.Save()

	utils.SuccessWithMessage(c, "登出成功", nil)
}

// Password 修改密码
func (ac *AuthController) Password(c *gin.Context) {
	var req PasswordChangeRequest
	if err := c.ShouldBind(&req); err != nil {
		utils.ValidationError(c, err)
		return
	}

	// 对密码进行Base64解码
	decodedOldPassword, err := utils.Base64Decode(req.OldPassword)
	if err != nil {
		utils.BadRequest(c, "旧密码解码失败")
		return
	}
	req.OldPassword = decodedOldPassword

	decodedNewPassword, err := utils.Base64Decode(req.NewPassword)
	if err != nil {
		utils.BadRequest(c, "新密码解码失败")
		return
	}
	req.NewPassword = decodedNewPassword

	decodedConfirmNewPassword, err := utils.Base64Decode(req.ConfirmNewPassword)
	if err != nil {
		utils.BadRequest(c, "确认新密码解码失败")
		return
	}
	req.ConfirmNewPassword = decodedConfirmNewPassword

	// 获取session
	session := sessions.Default(c)

	// 检查用户是否已登录
	userID := session.Get("user_id")
	if userID == nil {
		utils.Unauthorized(c, "用户未登录")
		return
	}

	// 从数据库加载完整的用户信息
	var user models.User
	if err := ac.DB.First(&user, userID).Error; err != nil {
		utils.Unauthorized(c, "用户不存在")
		return
	}

	// 验证旧密码
	if !utils.CheckPassword(req.OldPassword, user.Password) {
		utils.Unauthorized(c, "旧密码不正确")
		return
	}

	// 加密新密码
	hashedPassword, err := utils.HashPassword(req.NewPassword)
	if err != nil {
		utils.InternalServerError(c, "密码加密失败")
		return
	}

	// 更新密码
	user.Password = hashedPassword
	if err := ac.DB.Save(&user).Error; err != nil {
		utils.InternalServerError(c, "更新密码失败")
		return
	}

	utils.SuccessWithMessage(c, "密码修改成功", nil)
}

// Index 首页
func (ac *AuthController) Index(c *gin.Context) {
	// 获取session
	session := sessions.Default(c)

	// 检查用户是否已登录
	userID := session.Get("user_id")
	if userID == nil {
		utils.Unauthorized(c, "用户未登录")
		return
	}

	// 从数据库加载完整的用户信息
	var user models.User
	if err := ac.DB.Preload("Roles").First(&user, userID).Error; err != nil {
		utils.Unauthorized(c, "用户不存在")
		return
	}

	// 清除密码字段
	user.Password = ""

	utils.SuccessWithMessage(c, "获取用户信息成功", gin.H{
		"user": gin.H{
			"id":            user.ID,
			"username":      user.Username,
			"real_name":     user.RealName,
			"phone":         user.Phone,
			"email":         user.Email,
			"status":        user.Status,
			"last_login_at": user.LastLoginAt.Format("2006-01-02 15:04:05"),
			"last_login_ip": user.LastLoginIP,
			"sign":          user.Sign,
			"gender":        user.Gender,
			"mobile":        user.Mobile,
			"avatar_url":    user.AvatarURL,
			"login_count":   user.LoginCount,
			"created_at":    user.CreatedAt.Format("2006-01-02 15:04:05"),
			"updated_at":    user.UpdatedAt.Format("2006-01-02 15:04:05"),
		},
	})
}

// UpdateProfile 更新用户资料
func (ac *AuthController) UpdateProfile(c *gin.Context) {
	var req UpdateProfileRequest
	if err := c.ShouldBind(&req); err != nil {
		utils.ValidationError(c, err)
		return
	}

	// 获取session
	session := sessions.Default(c)

	// 检查用户是否已登录
	userID := session.Get("user_id")
	if userID == nil {
		utils.Unauthorized(c, "用户未登录")
		return
	}

	// 从数据库加载完整的用户信息
	var user models.User
	if err := ac.DB.First(&user, userID).Error; err != nil {
		utils.Unauthorized(c, "用户不存在")
		return
	}

	// 创建更新map，过滤空值
	updates := make(map[string]interface{})
	if req.RealName != "" {
		updates["real_name"] = req.RealName
	}
	if req.Phone != "" {
		updates["phone"] = req.Phone
	}
	if req.Email != "" {
		updates["email"] = req.Email
	}
	if req.Sign != "" {
		updates["sign"] = req.Sign
	}
	if req.Gender != "" {
		updates["gender"] = req.Gender
	}
	if req.AvatarURL != "" {
		updates["avatar_url"] = req.AvatarURL
	}

	// 更新用户资料
	if err := ac.DB.Model(&user).Updates(updates).Error; err != nil {
		utils.InternalServerError(c, "更新用户资料失败")
		return
	}

	// 清除密码字段
	user.Password = ""

	utils.SuccessWithMessage(c, "用户资料更新成功", gin.H{
		"user": gin.H{
			"id":            user.ID,
			"username":      user.Username,
			"real_name":     user.RealName,
			"phone":         user.Phone,
			"email":         user.Email,
			"status":        user.Status,
			"last_login_at": user.LastLoginAt.Format("2006-01-02 15:04:05"),
			"last_login_ip": user.LastLoginIP,
			"sign":          user.Sign,
			"gender":        user.Gender,
			"mobile":        user.Mobile,
			"avatar_url":    user.AvatarURL,
			"login_count":   user.LoginCount,
			"created_at":    user.CreatedAt.Format("2006-01-02 15:04:05"),
			"updated_at":    user.UpdatedAt.Format("2006-01-02 15:04:05"),
		},
	})
}

// CheckSession 检查会话状态
func (ac *AuthController) CheckSession(c *gin.Context) {
	// 获取session
	session := sessions.Default(c)

	// 检查用户是否已登录
	userID := session.Get("user_id")
	if userID == nil {
		utils.Error(c, 401, "用户未登录")
		return
	}

	// 返回会话信息
	response := gin.H{
		"logged_in":  true,
		"user_id":    session.Get("user_id"),
		"username":   session.Get("username"),
		"real_name":  session.Get("real_name"),
		"status":     session.Get("status"),
		"login_time": time.Unix(session.Get("login_time").(int64), 0).Format("2006-01-02 15:04:05"),
	}

	utils.SuccessWithMessage(c, "会话有效", response)
}

// GetProfile 获取用户信息
func (ac *AuthController) GetProfile(c *gin.Context) {
	// 获取session
	session := sessions.Default(c)
	// 检查用户是否已登录
	userID := session.Get("user_id")
	if userID == nil {
		utils.Unauthorized(c, "用户未认证")
		return
	}
	// 获取用户详细信息
	var user models.User
	if err := ac.DB.Preload("Roles.Permissions").First(&user, userID).Error; err != nil {
		utils.Unauthorized(c, "用户不存在")
		return
	}
	// 清除密码字段
	user.Password = ""
	utils.Success(c, user)
}

// VerifySession 验证会话
func (ac *AuthController) VerifySession(c *gin.Context) {
	// 获取session
	session := sessions.Default(c)

	// 检查用户是否已登录
	userID := session.Get("user_id")
	if userID == nil {
		utils.Success(c, gin.H{
			"valid":   false,
			"message": "用户未登录",
		})
		return
	}

	// 验证用户是否仍然存在
	var user models.User
	if err := ac.DB.First(&user, userID).Error; err != nil {
		utils.Success(c, gin.H{
			"valid":   false,
			"message": "用户不存在",
		})
		return
	}

	// 检查用户状态
	if user.Status != "active" {
		utils.Success(c, gin.H{
			"valid":   false,
			"message": "用户已被禁用",
		})
		return
	}

	// 清除密码字段
	user.Password = ""

	// 返回用户基本信息
	utils.Success(c, gin.H{
		"valid": true,
		"user": gin.H{
			"id":            user.ID,
			"username":      user.Username,
			"real_name":     user.RealName,
			"phone":         user.Phone,
			"email":         user.Email,
			"status":        user.Status,
			"last_login_at": user.LastLoginAt.Format("2006-01-02 15:04:05"),
			"last_login_ip": user.LastLoginIP,
			"sign":          user.Sign,
			"gender":        user.Gender,
			"mobile":        user.Mobile,
			"avatar_url":    user.AvatarURL,
			"login_count":   user.LoginCount,
			"created_at":    user.CreatedAt.Format("2006-01-02 15:04:05"),
			"updated_at":    user.UpdatedAt.Format("2006-01-02 15:04:05"),
		},
	})
}
